// package com.dong.sqltoy.tenant;
//
// import org.sagacity.sqltoy.config.model.SqlToyConfig;
// import org.sagacity.sqltoy.config.model.OperateType;
// import org.sagacity.sqltoy.SqlToyContext;
// import org.sagacity.sqltoy.config.model.SqlToyResult;
// import org.sagacity.sqltoy.plugins.SqlInterceptor;
//
// import org.sagacity.sqltoy.utils.StringUtil;
// import org.slf4j.Logger;
// import org.slf4j.LoggerFactory;
//
// import java.lang.reflect.Field;
// import java.util.ArrayList;
// import java.util.List;
// import java.util.Map;
// import java.util.regex.Matcher;
// import java.util.regex.Pattern;
//
// /**
//  * SqlToy多租户拦截器，用于动态拼接租户字段作为查询条件
//  * 支持自动填充租户ID和动态添加租户过滤条件
//  */
// public class TenantSqlInterceptor implements SqlInterceptor
// {
//     private static final Logger logger = LoggerFactory.getLogger(TenantSqlInterceptor.class);
//
//     /**
//      * 租户字段名
//      */
//     private String tenantField = "tenant_id";
//
//     /**
//      * 租户ID参数名
//      */
//     private String tenantParamName = "tenantId";
//
//     /**
//      * 需要忽略租户过滤的表名
//      */
//     private List<String> ignoreTables = new ArrayList<>();
//
//     /**
//      * SQL关键字正则表达式
//      */
//     private static final Pattern SQL_KEYWORD_PATTERN = Pattern.compile(
//             "\\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|AND|OR|JOIN|ON|GROUP|BY|HAVING|ORDER|LIMIT|OFFSET)\\b",
//             Pattern.CASE_INSENSITIVE
//     );
//
//     /**
//      * FROM子句正则表达式
//      */
//     private static final Pattern FROM_CLAUSE_PATTERN = Pattern.compile(
//             "\\bFROM\\s+([a-zA-Z0-9_]+)",
//             Pattern.CASE_INSENSITIVE
//     );
//
//     @Override
//     public SqlToyResult decorate(SqlToyContext sqlToyContext, SqlToyConfig sqlToyConfig,
//                                  OperateType operateType, SqlToyResult sqlToyResult,
//                                  Class entityClass, Integer dbType)
//     {
//
//         try {
//             // 1. 检查是否需要处理租户逻辑
//             if (!needProcessTenant(sqlToyContext, entityClass, operateType)) {
//                 return sqlToyResult;
//             }
//
//             // 2. 获取当前租户ID
//             String tenantId = getCurrentTenantId(sqlToyContext);
//             if (StringUtil.isBlank(tenantId)) {
//                 logger.warn("租户ID为空，不进行租户过滤处理");
//                 return sqlToyResult;
//             }
//             if (operateType.equals(OperateType.load) || operateType.equals(OperateType.loadAll)
//                     || operateType.equals(OperateType.unique)
//                     || operateType.equals(OperateType.singleTable)){
//
//             }else if(operateType.equals(OperateType.update) || operateType.equals(OperateType.updateAll)
//                     || operateType.equals(OperateType.delete) || operateType.equals(OperateType.deleteAll)){
//
//             }else if(operateType.equals(OperateType.saveOrUpdate){
//
//             }else if(operateType.equals(OperateType.saveOrUpdate){
//
//             }
//
//                 // 3. 根据操作类型处理
//             switch (operateType) {
//                 case SELECT:
//                     return handleSelectOperation(sqlToyContext, sqlToyResult, tenantId);
//                 case INSERT:
//                     return handleInsertOperation(sqlToyContext, sqlToyResult, tenantId, entityClass);
//                 case UPDATE:
//                     return handleUpdateOperation(sqlToyContext, sqlToyResult, tenantId);
//                 case DELETE:
//                     return handleDeleteOperation(sqlToyContext, sqlToyResult, tenantId);
//                 default:
//                     return sqlToyResult;
//             }
//         } catch (Exception e) {
//             logger.error("租户拦截器处理异常", e);
//             return sqlToyResult;
//         }
//     }
//
//     /**
//      * 判断是否需要处理租户逻辑
//      */
//     private boolean needProcessTenant(SqlToyContext sqlToyContext, Class entityClass, OperateType operateType)
//     {
//         // 检查是否忽略租户过滤
//         if (isIgnoreTenant(sqlToyContext, entityClass)) {
//             return false;
//         }
//
//         // 检查操作类型是否需要处理
//         return operateType == OperateType.SELECT ||
//                 operateType == OperateType.INSERT ||
//                 operateType == OperateType.UPDATE ||
//                 operateType == OperateType.DELETE;
//     }
//
//     /**
//      * 判断是否忽略租户过滤
//      */
//     private boolean isIgnoreTenant(SqlToyContext sqlToyContext, Class entityClass)
//     {
//         // 1. 检查实体类是否需要忽略
//         if (entityClass != null && entityClass.isAnnotationPresent(TenantIgnore.class)) {
//             return true;
//         }
//
//         // 2. 检查方法是否需要忽略（通过SqlToyContext的属性）
//         Map<String, Object> attributes = sqlToyContext.getAttributes();
//         if (attributes != null && Boolean.TRUE.equals(attributes.get("ignoreTenant"))) {
//             return true;
//         }
//
//         // 3. 检查是否是系统表
//         String sql = sqlToyContext.getSql();
//         if (sql != null) {
//             Matcher matcher = FROM_CLAUSE_PATTERN.matcher(sql);
//             while (matcher.find()) {
//                 String tableName = matcher.group(1);
//                 if (ignoreTables.contains(tableName.toLowerCase())) {
//                     return true;
//                 }
//             }
//         }
//
//         return false;
//     }
//
//     /**
//      * 获取当前租户ID
//      */
//     private String getCurrentTenantId(SqlToyContext sqlToyContext)
//     {
//         // 1. 从SqlToyContext的属性中获取
//         Map<String, Object> attributes = sqlToyContext.getAttributes();
//         if (attributes != null && attributes.containsKey(tenantParamName)) {
//             Object tenantIdObj = attributes.get(tenantParamName);
//             return tenantIdObj != null ? tenantIdObj.toString() : null;
//         }
//
//         // 2. 从ThreadLocal中获取（需要自定义TenantContextHolder）
//         try {
//             Class<?> tenantContextClass = Class.forName("com.yourproject.context.TenantContextHolder");
//             Field tenantField = tenantContextClass.getDeclaredField("TENANT_HOLDER");
//             tenantField.setAccessible(true);
//             ThreadLocal<String> tenantHolder = (ThreadLocal<String>) tenantField.get(null);
//             return tenantHolder.get();
//         } catch (Exception e) {
//             logger.debug("未找到TenantContextHolder，使用默认租户ID获取方式");
//         }
//
//         // 3. 从统一字段处理器中获取
//         if (sqlToyContext.getUnifyFieldsHandler() != null) {
//             return sqlToyContext.getUnifyFieldsHandler().getUserTenantId();
//         }
//
//         return null;
//     }
//
//     /**
//      * 处理查询操作，添加租户过滤条件
//      */
//     private SqlToyResult handleSelectOperation(SqlToyContext sqlToyContext, SqlToyResult sqlToyResult, String tenantId)
//     {
//         String sql = sqlToyResult.getSql();
//         if (StringUtil.isBlank(sql)) {
//             return sqlToyResult;
//         }
//
//         // 检查SQL是否已经包含租户条件
//         if (sql.toLowerCase().contains(tenantField + " =")) {
//             logger.debug("SQL已包含租户条件，跳过处理");
//             return sqlToyResult;
//         }
//
//         // 添加租户过滤条件
//         String newSql = addTenantConditionToSelect(sql, tenantId);
//         sqlToyResult.setSql(newSql);
//
//         // 添加租户参数
//         Map<String, Object> params = sqlToyResult.getParams();
//         if (params != null && !params.containsKey(tenantParamName)) {
//             params.put(tenantParamName, tenantId);
//         }
//
//         logger.debug("查询SQL添加租户条件：{}", newSql);
//         return sqlToyResult;
//     }
//
//     /**
//      * 处理插入操作，自动填充租户ID
//      */
//     private SqlToyResult handleInsertOperation(SqlToyContext sqlToyContext, SqlToyResult sqlToyResult,
//                                                String tenantId, Class entityClass)
//     {
//         String sql = sqlToyResult.getSql();
//         if (StringUtil.isBlank(sql)) {
//             return sqlToyResult;
//         }
//
//         // 检查SQL是否已经包含租户字段
//         if (sql.toLowerCase().contains(tenantField)) {
//             logger.debug("插入SQL已包含租户字段，跳过处理");
//             return sqlToyResult;
//         }
//
//         // 添加租户字段到INSERT语句
//         String newSql = addTenantFieldToInsert(sql, tenantId);
//         sqlToyResult.setSql(newSql);
//
//         logger.debug("插入SQL添加租户字段：{}", newSql);
//         return sqlToyResult;
//     }
//
//     /**
//      * 处理更新操作，添加租户过滤条件
//      */
//     private SqlToyResult handleUpdateOperation(SqlToyContext sqlToyContext, SqlToyResult sqlToyResult, String tenantId)
//     {
//         String sql = sqlToyResult.getSql();
//         if (StringUtil.isBlank(sql)) {
//             return sqlToyResult;
//         }
//
//         // 检查SQL是否已经包含租户条件
//         if (sql.toLowerCase().contains(tenantField + " =")) {
//             logger.debug("更新SQL已包含租户条件，跳过处理");
//             return sqlToyResult;
//         }
//
//         // 添加租户过滤条件
//         String newSql = addTenantConditionToUpdateDelete(sql, tenantId);
//         sqlToyResult.setSql(newSql);
//
//         // 添加租户参数
//         Map<String, Object> params = sqlToyResult.getParams();
//         if (params != null && !params.containsKey(tenantParamName)) {
//             params.put(tenantParamName, tenantId);
//         }
//
//         logger.debug("更新SQL添加租户条件：{}", newSql);
//         return sqlToyResult;
//     }
//
//     /**
//      * 处理删除操作，添加租户过滤条件
//      */
//     private SqlToyResult handleDeleteOperation(SqlToyContext sqlToyContext, SqlToyResult sqlToyResult, String tenantId)
//     {
//         String sql = sqlToyResult.getSql();
//         if (StringUtil.isBlank(sql)) {
//             return sqlToyResult;
//         }
//
//         // 检查SQL是否已经包含租户条件
//         if (sql.toLowerCase().contains(tenantField + " =")) {
//             logger.debug("删除SQL已包含租户条件，跳过处理");
//             return sqlToyResult;
//         }
//
//         // 添加租户过滤条件
//         String newSql = addTenantConditionToUpdateDelete(sql, tenantId);
//         sqlToyResult.setSql(newSql);
//
//         // 添加租户参数
//         Object[] params = sqlToyResult.getParamsValue();
//         if (params != null && !params.containsKey(tenantParamName)) {
//             params.put(tenantParamName, tenantId);
//         }
//
//         logger.debug("删除SQL添加租户条件：{}", newSql);
//         return sqlToyResult;
//     }
//
//     /**
//      * 为查询语句添加租户过滤条件
//      */
//     private String addTenantConditionToSelect(String sql, String tenantId)
//     {
//         String lowerSql = sql.toLowerCase();
//         int whereIndex = lowerSql.indexOf("where");
//
//         if (whereIndex > 0) {
//             // 找到WHERE子句，在其后添加租户条件
//             String prefix = sql.substring(0, whereIndex + 5);
//             String suffix = sql.substring(whereIndex + 5);
//
//             // 处理可能的AND/OR开头
//             if (suffix.trim().toLowerCase().startsWith("and") ||
//                     suffix.trim().toLowerCase().startsWith("or")) {
//                 return prefix + " " + tenantField + " = :" + tenantParamName + " " + suffix;
//             } else {
//                 return prefix + " " + tenantField + " = :" + tenantParamName + " and " + suffix;
//             }
//         } else {
//             // 没有WHERE子句，检查是否有GROUP BY、ORDER BY等
//             int groupByIndex = lowerSql.indexOf("group by");
//             int orderByIndex = lowerSql.indexOf("order by");
//             int limitIndex = lowerSql.indexOf("limit");
//
//             int insertPoint = sql.length();
//             if (groupByIndex > 0) {
//                 insertPoint = groupByIndex;
//             } else if (orderByIndex > 0) {
//                 insertPoint = orderByIndex;
//             } else if (limitIndex > 0) {
//                 insertPoint = limitIndex;
//             }
//
//             String prefix = sql.substring(0, insertPoint);
//             String suffix = sql.substring(insertPoint);
//
//             return prefix + " where " + tenantField + " = :" + tenantParamName + suffix;
//         }
//     }
//
//     /**
//      * 为插入语句添加租户字段
//      */
//     private String addTenantFieldToInsert(String sql, String tenantId)
//     {
//         // 处理INSERT INTO table (columns) VALUES (values) 格式
//         Pattern pattern = Pattern.compile(
//                 "(INSERT\\s+INTO\\s+\\w+\\s*\\()([^)]+)(\\)\\s*VALUES\\s*\\()([^)]+)(\\))",
//                 Pattern.CASE_INSENSITIVE | Pattern.DOTALL
//         );
//
//         Matcher matcher = pattern.matcher(sql);
//         if (matcher.find()) {
//             String part1 = matcher.group(1);
//             String columns = matcher.group(2);
//             String part3 = matcher.group(3);
//             String values = matcher.group(4);
//             String part5 = matcher.group(5);
//
//             // 添加租户字段到列列表
//             String newColumns = columns + ", " + tenantField;
//             // 添加租户值到值列表
//             String newValue = values + ", :" + tenantParamName;
//
//             return part1 + newColumns + part3 + newValue + part5;
//         }
//
//         // 处理INSERT INTO table VALUES (values) 格式
//         pattern = Pattern.compile(
//                 "(INSERT\\s+INTO\\s+\\w+\\s*VALUES\\s*\\()([^)]+)(\\))",
//                 Pattern.CASE_INSENSITIVE | Pattern.DOTALL
//         );
//
//         matcher = pattern.matcher(sql);
//         if (matcher.find()) {
//             // 这种情况需要知道表结构，这里简化处理
//             logger.warn("无法自动处理简化INSERT语句格式，请使用完整的INSERT语句格式");
//         }
//
//         return sql;
//     }
//
//     /**
//      * 为更新和删除语句添加租户过滤条件
//      */
//     private String addTenantConditionToUpdateDelete(String sql, String tenantId)
//     {
//         String lowerSql = sql.toLowerCase();
//         int whereIndex = lowerSql.indexOf("where");
//
//         if (whereIndex > 0) {
//             // 找到WHERE子句，在其后添加租户条件
//             String prefix = sql.substring(0, whereIndex + 5);
//             String suffix = sql.substring(whereIndex + 5);
//
//             // 处理可能的AND/OR开头
//             if (suffix.trim().toLowerCase().startsWith("and") ||
//                     suffix.trim().toLowerCase().startsWith("or")) {
//                 return prefix + " " + tenantField + " = :" + tenantParamName + " " + suffix;
//             } else {
//                 return prefix + " " + tenantField + " = :" + tenantParamName + " and " + suffix;
//             }
//         } else {
//             // 没有WHERE子句，添加WHERE子句
//             return sql + " where " + tenantField + " = :" + tenantParamName;
//         }
//     }
//
//     /**
//      * 获取SQL中的表名
//      */
//     private List<String> getTableNamesFromSql(String sql)
//     {
//         List<String> tableNames = new ArrayList<>();
//         Matcher matcher = FROM_CLAUSE_PATTERN.matcher(sql);
//
//         while (matcher.find()) {
//             String tableName = matcher.group(1);
//             if (!tableNames.contains(tableName.toLowerCase())) {
//                 tableNames.add(tableName.toLowerCase());
//             }
//         }
//
//         return tableNames;
//     }
//
//     /**
//      * 设置租户字段名
//      */
//     public void setTenantField(String tenantField)
//     {
//         this.tenantField = tenantField;
//     }
//
//
//     /**
//      * 设置需要忽略的表名
//      */
//     public void setIgnoreTables(List<String> ignoreTables)
//     {
//         this.ignoreTables = new ArrayList<>();
//         for (String table : ignoreTables) {
//             this.ignoreTables.add(table.toLowerCase());
//         }
//     }
//
//     /**
//      * 忽略租户过滤注解
//      */
//     public @interface TenantIgnore {
//     }
// }